home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / stk110 / stkref.doc < prev    next >
Text File  |  1991-02-25  |  23KB  |  793 lines
  1. **********************************************************************
  2.                     This file is part of
  3.  
  4.           STK -- The sprite toolkit -- version 1.1
  5.  
  6.               Copyright (C) Jari Karjala 1991
  7.  
  8. The sprite toolkit (STK) is a FreeWare toolkit for creating high
  9. resolution sprite graphics with PCompatible hardware. This toolkit 
  10. is provided as is without any warranty or such thing. See the file
  11. COPYING for further information.
  12.  
  13. **********************************************************************
  14.  
  15. GRTYPES
  16. ---------------------------------------------------------------------------
  17.   
  18.   Common type definitions for the graphics and sprite routines
  19.  
  20.  
  21.  
  22. #define NULL ((void*)0)
  23. typedef unsigned char BYTE;
  24. typedef unsigned int  WORD;
  25. typedef BYTE *BITMAP;
  26.  
  27.  
  28.  
  29. ---------------------------------------------------------------------------
  30. The SPR functions
  31. ---------------------------------------------------------------------------
  32.   
  33.   The basic sprite support system prototypes and structures.
  34.  
  35.  
  36.  
  37. extern int spr_pass_delay;
  38.  
  39.   The delay after setvisualpage() before removing old objects in
  40.   the funtion spr_next_pass(). 
  41.   Many EGA/VGA cards need some milliseconds to switch pages, 
  42.   the sprites flicker if this delay is too short.
  43.   
  44.   If someone has better solutions in dealing with this problem,
  45.   I sure would like to know about them.
  46.   
  47.   Time is given in milliseconds and the default is 10 ms for EGA
  48.   and 0 ms for Hercules (use spr_regulate_speed to balance the frame
  49.   rate with different display adapters).
  50.  
  51.  
  52.  
  53. #define spr_max_x gr_max_x
  54. #define spr_max_y gr_max_y
  55.  
  56.   The maximum coordinate values for current graphics adapter.
  57.   Variables defined in module gr.c, and initialized in gr_start.
  58.   (It is faster to use variables instead of getmaxx() and getmaxy());
  59.  
  60.  
  61.  
  62. typedef void *SPRITE;
  63.  
  64.   The sprite type is private. The handle must be void pointer due
  65.   to the Turbo C which does not allow "struct _sprite *SPRITE" without
  66.   struct _sprite definition in the same file.
  67.  
  68.  
  69.  
  70. void spr_initialize(int graphicsdriver);
  71.  
  72.   Initialize the sprite system to the given display hardware.
  73.   Supported graphicsdrivers: EGA (only two colors), EGAMONO and HERCMONO.
  74.   
  75.   The visual page is set to 0.
  76.   
  77.   NOTE: This function must be called before any other sprite funtions
  78.         and the graphics mode must have been set before this call.
  79.   
  80.   graphicsdriver  The BGI identifier for the graphics driver used.
  81.  
  82.  
  83.  
  84. SPRITE spr_create(WORD w, WORD h, 
  85.                   BITMAP pic, BITMAP mask, 
  86.                   BYTE res, WORD ID);
  87.  
  88.   Create a sprite from the given bitmaps.
  89.   
  90.   w,h   Width (must be < 512) and height (<256) of sprite in pixels
  91.   pic   The picture bitmap for the sprite
  92.   mask  The mask bitmap for the sprite
  93.   res   The number of steps wanted per 8 bit interval in horizontal
  94.         direction (1,2,4,8). For example, the value 8 gives one
  95.         pixel resolution in X-direction.
  96.   ID    The user supplied ID for the sprite (usually index into an 
  97.         array and/or sprite type identifier).
  98.   
  99.   Return: the newly created sprite or NULL if parameter error,
  100.             sprite too big or out-of-memory
  101.  
  102.  
  103.  
  104. SPRITE spr_share(SPRITE spr, BYTE n);
  105.  
  106.   Create a shared version of the given sprite. This allows at
  107.   most n spr_copies which all share the shape data thus saving
  108.   quite much memory.
  109.   
  110.   spr   The sprite to share
  111.   n     The maximum number of shared copies
  112.   
  113.   Return: New SPRITE or NULL if error (out of memory, spr==NULL)
  114.  
  115.  
  116.  
  117. SPRITE spr_copy(SPRITE spr, WORD id);
  118.  
  119.   Create a copy of the given sprite. If the sprite was shared
  120.   with spr_share then a shared copy is created. 
  121.   
  122.   spr   The sprite to share
  123.   id    The ID for the new sprite
  124.   
  125.   Return: New SPRITE or NULL if error (out of memory, spr was NULL, 
  126.             no more shared copies)
  127.  
  128.  
  129.  
  130. void spr_put(SPRITE spr, WORD x, WORD y);
  131.  
  132.   Put the sprite into the given position in the display. 
  133.   Actually the call has no effect on screen until spr_next_pass() is
  134.   called next time and the sprite will disappear after the next
  135.   spr_next_pass() call after that.
  136.   
  137.   NOTE: Cannot be called twice for the same sprite before spr_hide() or
  138.         spr_next_pass().
  139.   
  140.   spr   The sprite to put
  141.   x     The X coordinate
  142.   y     The Y coordinate
  143.  
  144.  
  145.  
  146. void spr_hide(SPRITE spr);
  147.  
  148.   Undo a spr_put for the sprite. This function only removes the sprite
  149.   from internal display list since the spr_put did not actually put the 
  150.   sprite into the screen.
  151.   
  152.   spr   The sprite to hide
  153.  
  154.  
  155.  
  156. void spr_delete(SPRITE spr);
  157.  
  158.   Delete the given sprite and release associated memory buffers.
  159.   Also spr_hides the sprite.
  160.   
  161.   spr   The sprite to delete
  162.  
  163.  
  164.  
  165. WORD spr_next_pass(void);
  166.  
  167.   1. Draw all sprites into the hidden screen page.
  168.   2. Make the hidden screen page visible.
  169.   3. Delete old sprites from the new hidden page.
  170.   
  171.   Return: The current visual page number
  172.  
  173.  
  174.  
  175. void spr_regulate_speed(void);
  176.  
  177.   This function tries to regulate the frame speed by delaying if
  178.   we are doing more frames per second than we should. The target 
  179.   speed is 1 frame per one clock tick (about 18 frames per second).
  180.   This is a reasonable target speed for 286 machines.
  181.   This function should be called after each spr_next_pass() call.
  182.  
  183.  
  184.  
  185. /***** Information retrieving functions *****/
  186.  
  187. WORD spr_get_id(SPRITE spr);
  188.  
  189.   Return the user supplied identifier of the sprite
  190.  
  191.  
  192.  
  193. WORD spr_get_x(SPRITE spr);
  194.  
  195.   Return the X coordinate of the sprite in pixels from top-left
  196.  
  197.  
  198.  
  199. WORD spr_get_y(SPRITE spr);
  200.  
  201.   Return the Y coordinate of the sprite in pixels from top-left
  202.  
  203.  
  204.  
  205. WORD spr_get_width(SPRITE spr);
  206.  
  207.   Return the width of the sprite in pixels
  208.  
  209.  
  210.  
  211. WORD spr_get_height(SPRITE spr);
  212.  
  213.   Return the height of the sprite in pixels
  214.  
  215.  
  216.  
  217.  
  218.  
  219. ---------------------------------------------------------------------------
  220. The SPR_FIO functions
  221. ---------------------------------------------------------------------------
  222.   
  223.   The functions for reading sprites from a file.
  224.  
  225.  
  226.  
  227. SPRITE spr_fio_read_smp(char *smpfile, BYTE res, WORD ID);
  228.  
  229.   Create a sprite from the given SMP file.
  230.   
  231.   smpfile   The sprite bitmap file name.
  232.   res       The number of steps wanted per 8 bit interval in horizontal
  233.             direction (1,2,4,8). For example, the value 8 gives one
  234.             pixel resolution in X-direction.
  235.   ID        The user supplied ID for the sprite (not obligatory)
  236.   
  237.   Return: the newly created sprite or NULL if file not found, read
  238.           error or out-of-memory
  239.  
  240.  
  241.  
  242.  
  243.  
  244. ---------------------------------------------------------------------------
  245. The SPR_HIT functions
  246. ---------------------------------------------------------------------------
  247.   
  248.   The sprite collision detection routines.
  249.   
  250.   Collisions may be checked only for the sprites which have been 
  251.   spr_put() since the last call to spr_next_pass().
  252.   All checks are made against the mask-bitmaps of the sprites.
  253.   
  254.  
  255.  
  256.  
  257. int spr_hit_with_point(SPRITE spr, WORD x, WORD y);
  258.  
  259.   Check whether the given point is inside the given sprite.
  260.   
  261.   Return: 0 if no collision, negative otherwise.
  262.  
  263.  
  264.  
  265. int spr_hit(SPRITE spr1, SPRITE spr2);
  266.  
  267.   Check whether the given sprites collide against each other.
  268.   
  269.   Return: 0 if no collision, negative otherwise.
  270.  
  271.  
  272.  
  273. SPRITE spr_hit_first(SPRITE spr);
  274.  
  275.   Find the first sprite colliding the given sprite. Use spr_hit_next 
  276.   to get the next sprites.
  277.   Return: Sprite or NULL if no collision
  278.  
  279.  
  280.  
  281. SPRITE spr_hit_next(SPRITE spr);
  282.  
  283.   Find the next sprite colliding with the given sprite. 
  284.   Return: Sprite or NULL if no collision
  285.  
  286.  
  287.  
  288.  
  289.  
  290. ---------------------------------------------------------------------------
  291. The SPR_ANIM functions
  292. ---------------------------------------------------------------------------
  293.   
  294.   Routines for automatic sprite animation and movement.
  295.  
  296.  
  297.  
  298. /***** Datatypes *****/
  299.  
  300. typedef void *ANIM_SPRITE;
  301.  
  302.   The animated sprite type is private. The handle must be void pointer 
  303.   due to the TC which does not allow "struct _anim_sprite *ANIM_SPRITE"  
  304.   without a "struct _anim_sprite" defined in the same file.
  305.  
  306.  
  307.  
  308.  
  309.   The information structure returned by the spr_anim_get_info():
  310.  
  311.  
  312. typedef struct _anim_spr_info {
  313.     int     x,y;                            /** location        **/
  314.     int     dx,dy;                          /** movement vector **/
  315.     int     lef, top, rig, bot;             /** limits          **/
  316.     WORD    frame, frame_delay, timeout;    /** time info       **/
  317.     WORD    id;     /** the user spesified id of current sprite **/
  318.     int     w,h;                            /** width&height    **/
  319. } ANIM_SPR_INFO;
  320.  
  321. /***** Literal defines *****/
  322.  
  323.  
  324.   The values for fx_mode and fx_type: (See spr_anim_set_fx_handler)
  325.  
  326.  
  327. #define SPR_ANIM_FX_ALL         (0x0F) /** all fx       **/
  328. #define SPR_ANIM_FX_TIMEOUT     (1<<0) /** timeout      **/
  329. #define SPR_ANIM_FX_HIT_X_LIMIT (1<<1) /** hit x limit  **/
  330. #define SPR_ANIM_FX_HIT_Y_LIMIT (1<<2) /** hit y limit  **/
  331. #define SPR_ANIM_FX_HIT_SPRITE  (1<<3) /** hit other spr**/
  332.  
  333.  
  334.   
  335.   The FX_RET values for the fx_handler return codes:
  336.  
  337.  
  338. #define SPR_ANIM_FX_RET_NOTHING (0)     /** continue normally       **/
  339. #define SPR_ANIM_FX_RET_RE_PUT  (1)     /** put the sprite again    **/
  340. #define SPR_ANIM_FX_RET_STOP    (2)     /** stop the animation      **/
  341. #define SPR_ANIM_FX_RET_DELETE  (3)     /** delete the anim.sprite  **/
  342. #define SPR_ANIM_FX_RET_DESTROY (4)     /** destroy the anim.sprite **/
  343.  
  344. /***** Function prototypes *****/
  345.  
  346. ANIM_SPRITE spr_anim_create(WORD count, ...);
  347.  
  348.   Create an animated sprite from the given simple sprites.
  349.   The sprites must have the same width and height.
  350.   Set the following defaults:
  351.     x,y = 0,0
  352.     dx,dy = 0,0
  353.     lef,top,rig,bot = 0,0,spr_max_x,spr_max_y
  354.     frame_delay, timeout = 0,0
  355.     fx_mode = FX_ALL 
  356.     fx_handler = default_fx (TIMEOUT & HIT_SPRITE delete, LIMITs bounce.)
  357.   
  358.   count The number of simple sprites, at most 20.
  359.   ...   The simple sprites
  360.   
  361.   Return: ANIM_SPRITE if no errors or 
  362.            NULL if memory allocation error, count>20
  363.             or ... contains a NULL sprite.
  364.  
  365.  
  366.  
  367. void spr_anim_start(ANIM_SPRITE aspr);
  368.  
  369.   Start the sprite animation. 
  370.   
  371.   aspr  The animated sprite to use
  372.  
  373.  
  374.  
  375. void spr_anim_stop(ANIM_SPRITE aspr);
  376.  
  377.   Stop the animation of the given sprite. This means that after the 
  378.   next pass this sprite will not be shown nor updated. Sprite can
  379.   be restarted with the function spr_anim_start.
  380.   
  381.   aspr  The animated sprite to stop
  382.  
  383.  
  384.  
  385. void spr_anim_delete(ANIM_SPRITE aspr);
  386.  
  387.   Delete the given animated sprite. The simple sprites it contains are 
  388.   NOT deleted.
  389.   
  390.   aspr  The animated sprite to use
  391.  
  392.  
  393.  
  394. void spr_anim_destroy(ANIM_SPRITE aspr);
  395.  
  396.   Delete the given animated sprite. The simple sprites it contains are 
  397.   ALSO deleted.
  398.   
  399.   aspr  The animated sprite to destroy
  400.  
  401.  
  402.  
  403. WORD spr_anim_next_pass(void);
  404.  
  405.   This function handles the sprite animation and display.
  406.   1. Spr_put all animated sprites.
  407.   2. Check for special effects.
  408.     a. Call fx_handlers if necessary.
  409.     b. Act according to the fx_handler return values.
  410.   3. Call spr_next_pass.
  411.   4. Update frame indices and locations of all animated sprites.
  412.   
  413.   Return: The current visual page number
  414.  
  415.  
  416.  
  417. ANIM_SPR_INFO *spr_anim_get_info(ANIM_SPRITE aspr);
  418.  
  419.   Return a pointer into a static info structure of the sprite.
  420.   
  421.   NOTE: the structure is only a copy which is overwritten by the 
  422.         next call to this function.
  423.  
  424.  
  425.  
  426. void spr_anim_set_location(ANIM_SPRITE aspr, WORD x, WORD y);
  427.  
  428.   Set the location of the animated sprite.
  429.  
  430.  
  431.  
  432. void spr_anim_set_vector(ANIM_SPRITE aspr, int dx, int dy);
  433.  
  434.   Set the movement vector of the animated sprite. The (dx,dy) are added
  435.   to the (x,y) attributes of the sprite during every pass. Negative
  436.   values mean left and up directions in screen.
  437.  
  438.  
  439.  
  440. void spr_anim_set_limits(ANIM_SPRITE aspr,
  441.                          WORD lef, WORD top, WORD rig, WORD bot);
  442.  
  443.   Set the limits for the animated sprite. The function takes care
  444.   of the bottom/right adjustments due to the size of the sprite.
  445.   The fx_handler will be triggered by these limits, if allowed.
  446.   
  447.   Note again, that all simple sprites belonging to the animated sprite
  448.   must have the same width & heigth or the limit checking will not work.
  449.  
  450.  
  451.  
  452. void spr_anim_set_time(ANIM_SPRITE aspr,
  453.                        int frame, int frame_delay, int timeout);
  454.  
  455.   Set the frame delay and timeout values. (-1 means no change for
  456.   that value). 
  457.   
  458.   NOTE: The 'frame' MUST NOT be changed from an fx_handler!!
  459.   
  460.   frame         The current animation frame number (0..nr of frames-1)
  461.   frame_delay   The number of passes for each frame change (0=no change)
  462.   timeout       The number of passes before timeout action (0=infinite)
  463.  
  464.  
  465.  
  466. void spr_anim_set_fx_handler(ANIM_SPRITE aspr, 
  467.                              WORD fx_mask, 
  468.                              WORD (fx_handler)(ANIM_SPRITE,WORD,SPRITE));
  469.  
  470.   Sets the special effects handler function for the given ANIM_SPRITE.
  471.   
  472.   The function should have the following prototype:
  473.   
  474.     WORD handler_name(ANIM_SPRITE aspr, WORD fx_type, SPRITE spr);
  475.   
  476.   The function will be called with the following parameters:
  477.   aspr      the animated sprite whose handler this is, 
  478.   fx_type   the type of the effect which caused this call,
  479.   spr       the colliding sprite (if fx_type was HIT_SPRITE). 
  480.   
  481.   The function must return one of the SPR_ANIM_FX_RET values defined above.
  482.   
  483.   A NULL handler means that all special effects cause spr_anim_delete.
  484.   
  485.   fx_mask     The types of effects which cause a call to the handler,
  486.               for example: SPR_ANIM_FX_HIT_Y_LIMIT|SPR_ANIM_FX_HIT_X_LIMIT
  487.   fx_handler  The handler function.
  488.  
  489.  
  490.  
  491.  
  492.  
  493. ---------------------------------------------------------------------------
  494. The GR functions
  495. ---------------------------------------------------------------------------
  496.   
  497.   Support routines for graphics mode.
  498.  
  499.  
  500.  
  501. /***** Variables *****/
  502.  
  503. extern int gr_max_x;
  504. extern int gr_max_y;
  505.  
  506.   The maximum coordinate values for current graphics adapter.
  507.   (It is faster to use variables instead of getmaxx() and getmaxy());
  508.  
  509.  
  510.  
  511. extern int gr_text_mode;
  512. #define GR_MODE_OR      (1<<0)      /* OR the text over previous graphics */
  513. #define GR_MODE_CLEAR   (1<<1)      /* Clear the backgroud before print  */
  514. #define GR_MODE_CLEAR_FAST   (1<<2) /* Clear the bg before print FAST  */
  515.  
  516.   This variable defines the text writing mode when using gr_* functions
  517.   (default GR_MODE_CLEAR)
  518.   
  519.   The GR_MODE_CLEAR_FAST is limited to 8 pixel horizontal resolution,
  520.   i.e. coordinate positions (1,0) and (5,0) are considered to be same.
  521.  
  522.  
  523.  
  524. extern unsigned char far *gr_font_addr;
  525.  
  526.   Pointer into an byte array containing the character font for 
  527.   8x8 pixel fixed point font. Initialized to ROM font (FFA6:000E).
  528.   Used only with GR_MODE_CLEAR_FAST in those graphics modes which
  529.   are supported by the sprite functions.
  530.  
  531.  
  532.  
  533. extern int gr_visualpage;
  534. extern int gr_activepage;
  535.  
  536.   The current visual page and active drawing page, provided that
  537.   they have been changed only with gr_*page functions.
  538.  
  539.  
  540.  
  541. extern char gr_keys[128];
  542.  
  543.   Array of booleans for each key of the keyboard (indexed by the scan
  544.   code value). Non-zero if key is depressed, zero otherwise.
  545.   The array is updated during the kbd_grab, see the function 
  546.   gr_start_kbd_grab below. For example gr_keys[GR_KEY_ESC] is 1
  547.   if Esc is currently depressed and 0 if not. Multiple simultaneous 
  548.   keyspresses are detected correctly.
  549.  
  550.  
  551.  
  552. /***** Function prototypes *****/
  553.  
  554. void gr_detect(int type, int *graphdriver, int *graphmode);
  555. #define GR_TYPE_ANY 0   /* Any mode will do */
  556. #define GR_TYPE_SPR 1   /* The best possible mode for the sprite toolkit */
  557.  
  558.   Detect the graphics card and mode of the system.
  559.   The type parameter can be used to specify special requests.
  560.   
  561.   graphdriver and graphmode parameters are returned. These values can 
  562.   be used with the gr_start function. They contain the value -1
  563.   if some error occured (cannot find requested mode, etc)
  564.  
  565.  
  566.  
  567. void gr_start(int *graphdriver, int *graphmode);
  568.  
  569.   Initializes the graphics system. 
  570.   Search BGI drivers from the path defined in the enviroment variable BGIDIR
  571.   or current directory. 
  572.   Set videomode into the BIOS to fool mouse drivers with Hercules graphics.
  573.   Set gr_end at exit and ctrl-C signals.
  574.   Terminate with error message if initialization fails.
  575.   
  576.   graphdriver   pointer to the driver ID (or DETECT)
  577.   graphmode     pointer to the mode ID
  578.  
  579.  
  580.  
  581. void gr_end(void);
  582.  
  583.   Returns to the text mode
  584.  
  585.  
  586.  
  587. void gr_setactivepage(int page);
  588.  
  589.   Set the active graphics page for writing and reading (0/1).
  590.   Also set the 'gr_activepage' variable
  591.  
  592.  
  593.  
  594. void gr_setvisualpage(int page);
  595.  
  596.   Set the visual graphics page
  597.   Also set the 'gr_visualpage' variable
  598.  
  599.  
  600.  
  601. void gr_putch(char ch);
  602. void gr_puts(char *s);
  603. void gr_printf(char *s,...);
  604. #define gr_gotoxy(x, y) moveto(x*8, y*8)
  605.  
  606.   gr_putch, gr_puts, gr_printf work as the as in text modes.
  607.   '\n', '\r' are handled as in standard text modes. 
  608.   The string to be output must not exceed 100 characters.
  609.   Scrolling or backspacing not implemented.
  610.  
  611.  
  612.  
  613. void gr_center_printf(int y, char *s,...);
  614.  
  615.   Print text horizontally centered.
  616.   (x centered, at given y in pixels).
  617.   The string to be output must not exceed 100 characters.
  618.  
  619.  
  620.  
  621. void gr_xy_printf(int x, int y, char *s,...);
  622.  
  623.   printf at the given position. (x and y in pixels) 
  624.   The string to be output must not exceed 100 characters.
  625.  
  626.  
  627.  
  628. void gr_dual_center_printf(int y, char *s,...);
  629.  
  630.   Print text into both graphics pages at the given position.
  631.   (x centered, at given y in pixels)
  632.   The string to be output must not exceed 100 characters.
  633.  
  634.  
  635.  
  636. void gr_dual_xy_printf(int x, int y, char *s,...);
  637.  
  638.   printf into both graphics pages at the given position.
  639.   (x and y in pixels)
  640.   The string to be output in gr_printf must not exceed 100 characters.
  641.  
  642.  
  643.  
  644. int gr_inkey(void);
  645.  
  646.   Return a keypress if one pending, otherwise 0.
  647.   Extended codes contain 0 in the low byte.
  648.   
  649.   Keyboard buffer head and tail are set equal to disable auto-repeat,
  650.   but it doesn't always work...
  651.  
  652.  
  653.  
  654. char *gr_gets(char *cpdest, int max_len);
  655.  
  656.   Read a string from screen in graphics mode.
  657.   The result is placed into cpdest, at most max_len characters are
  658.   read (max_len must be less than 80). Return cpdest of NULL
  659.   Backspace deletes characters, Esc returns a NULL pointer.
  660.  
  661.  
  662.  
  663. void gr_start_kbd_grab(void);
  664.  
  665.   Set a new handler for the keyboard. This handler sets and resets
  666.   the gr_keys array values for each scancode received, then flushes the 
  667.   keyboard buffer, and after that calls the old handler.
  668.  
  669.  
  670.  
  671. void gr_end_kbd_grab(void);
  672.  
  673.   End the kbd grab, ie restore the original keyboard handler.
  674.  
  675.  
  676.  
  677.  
  678.   Defines for the scan codes of some keys. See others from
  679.   some book, for example Peter Norton's Programmers guide or
  680.   perhaps you could figure them out just by counting keycaps...
  681.  
  682.  
  683. #define GR_KEY_ESC  1
  684. #define GR_KEY_1    2
  685. #define GR_KEY_2    3
  686. #define GR_KEY_3    4
  687. #define GR_KEY_4    5
  688. #define GR_KEY_5    6
  689. #define GR_KEY_6    7
  690. #define GR_KEY_7    8
  691. #define GR_KEY_8    9
  692. #define GR_KEY_9    10
  693. #define GR_KEY_0    11
  694.  
  695. #define GR_KEY_TAB  15
  696. #define GR_KEY_Q    16
  697. #define GR_KEY_W    17
  698. #define GR_KEY_E    18
  699. #define GR_KEY_R    19 
  700. #define GR_KEY_T    20
  701. #define GR_KEY_Y    21
  702. #define GR_KEY_U    22
  703. #define GR_KEY_I    23
  704. #define GR_KEY_O    24
  705. #define GR_KEY_P    25
  706. #define GR_KEY_A    30
  707. #define GR_KEY_S    31
  708. #define GR_KEY_D    32
  709. #define GR_KEY_F    33
  710. #define GR_KEY_G    34
  711. #define GR_KEY_H    35
  712. #define GR_KEY_J    36
  713. #define GR_KEY_K    37
  714. #define GR_KEY_L    38
  715. #define GR_KEY_Z    44
  716. #define GR_KEY_X    45 
  717. #define GR_KEY_C    46
  718. #define GR_KEY_V    47
  719. #define GR_KEY_B    48
  720. #define GR_KEY_N    49
  721. #define GR_KEY_M    50
  722. #define GR_KEY_COMMA    51
  723. #define GR_KEY_DOT      52
  724. #define GR_KEY_SPACE    57
  725. #define GR_KEY_ARROW_UP     72
  726. #define GR_KEY_ARROW_DOWN   80
  727. #define GR_KEY_ARROW_LEFT   75
  728. #define GR_KEY_ARROW_RIGHT  77
  729.  
  730.  
  731. ---------------------------------------------------------------------------
  732. The MOUSE functions
  733. ---------------------------------------------------------------------------
  734.   
  735.   The mouse interface through INT 33.
  736.   NOTE: The pointer is not visible in the 2nd page of a Hercules card
  737.  
  738.  
  739.  
  740.  
  741.   Codes for mouse button presses: 
  742.  
  743.  
  744. #define BUTTON_LEFT         1
  745. #define BUTTON_RIGHT        2
  746. #define BUTTON_MS_MIDDLE    (BUTTON_RIGHT | BUTTON_LEFT)
  747. #define BUTTON_MIDDLE       4
  748.  
  749. typedef unsigned int MOUSE_POINTER[2][16];
  750.  
  751.   The mouse cursor datatype.
  752.   First mask and then shape bitmap (must be WORDs) 
  753.  
  754.  
  755.  
  756.  
  757.   Predefined mouse cursor shapes:
  758.  
  759.  
  760. extern MOUSE_POINTER mouse_pointer_arrow;    /* HotSpot 1,1   */
  761. extern MOUSE_POINTER mouse_pointer_hourglass;/* HotSpot 7,7  */
  762. extern MOUSE_POINTER mouse_pointer_cross;    /* HotSpot 7,7   */
  763.  
  764. /***** Function prototypes *****/
  765.  
  766. int     mouse_initialize(void);
  767.  
  768.   Initialize the mouse driver, set the pointer shape to arrow,
  769.   set pointer window to full screen and enable cursor.
  770.   Return: the number of buttons or 0 if no mouse driver detected
  771.  
  772.  
  773.  
  774.  
  775.   For the following functions, see the mouse documention
  776.  
  777.  
  778. int     mouse_driver_init(void);                                /**  0 **/
  779. void    mouse_show_pointer(void);                               /**  1 **/
  780. void    mouse_hide_pointer(void);                               /**  2 **/
  781. void    mouse_get_pointer_xy(int *x, int *y);                   /**  3 **/
  782. void    mouse_get_rel_pointer_xy(int *x, int *y);               /** 11 **/
  783. int     mouse_get_buttons(void);                                /**  3 **/
  784. int     mouse_get_presses(int buttons);                         /**  5 **/
  785. int     mouse_get_releases(int buttons);                        /**  6 **/
  786. void    mouse_set_pointer_xy(int x, int y);                     /**  4 **/
  787. void    mouse_set_sensitivity(int x, int y);                    /** 15 **/
  788. void    mouse_set_pointer_shape(int HotX, int HotY, MOUSE_POINTER shape);
  789. void    mouse_set_pointer_window(int a, int b, int c, int d);    /**  7 **/
  790. void    mouse_disable_pointer_window(int a, int b, int c, int d);/** 16 **/
  791. void    mouse_set_light_pen(int a);                         /** 13 & 14 **/
  792.  
  793.